package org.votech.ds6.plastlets;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URL;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashSet;
   import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.astrogrid.acr.builtin.ACR;
  import org.jdesktop.jdic.desktop.Desktop;
  import org.jdesktop.jdic.desktop.DesktopException;
  import org.jdesktop.jdic.desktop.Message;
  import org.votech.plastic.PlasticHubListener;
  import org.votech.plastic.managers.AcrManager;
  import org.votech.plastic.managers.PlasticManager;
  import org.votech.plastic.managers.AcrManager.AcrObserver;
  import org.votech.plastic.managers.PlasticManager.PlasticHubObserver;
  /***
   * Manages creation and registration of Plastlets.
   * @author jdt
   *
   */
  public class PlastletsManager implements PlasticHubObserver, AcrObserver {
  	
  	public interface PlastletChangeListener {
  		void plastletsChanged();
  	}
  	private List<PlastletChangeListener> listeners = new ArrayList<PlastletChangeListener>();
  	public PlastletsManager(AcrManager acrManager, PlasticManager plasticManager) {
  		this.acrManager = acrManager;
  		this.plasticManager = plasticManager;
  		plasticManager.addObserver(plasticManager.new ObserverAdaptor(this));
  		acrManager.addObserver(acrManager.new ObserverAdaptor(this));
  	}
  	public void add(PlastletChangeListener listener) {
  		listeners.add(listener);
  	}
  	private void notifyListeners() {
  		for (PlastletChangeListener l : listeners) {
  			l.plastletsChanged();
  		}
  	}
  	
  
  	/***
  	 * Logger for this class
  	 */
  	private static final Log logger = LogFactory.getLog(PlastletsManager.class);
  
  	private PlasticManager plasticManager;
  
  	private Set<Plastlet> jdicPlastlets = new HashSet<Plastlet>();
  	private Set<Plastlet> acrPlastlets = new HashSet<Plastlet>();
  
  	private AcrManager acrManager;
  
  
  
  
  	public boolean enablePlastlet(Plastlet plastlet, boolean enable) {
  		Collection<Plastlet> plastlets = getPlastlets();
  		if (!plastlets.contains(plastlet)) return false;
  		final PlasticHubListener hub = plasticManager.getHub();
  		if (hub==null) return false;
  		boolean success;
  		if (enable) {
  			success = plastlet.register(hub);
  		} else {
  			success = plastlet.unregister();
  		}
  		return success;
  	}
  	
  	public Collection<Plastlet> getPlastlets() {
  		Set<Plastlet> allPlastlets = new HashSet<Plastlet>(acrPlastlets);
  		allPlastlets.addAll(jdicPlastlets);
  		return allPlastlets;
  	}
  	
  	private void unregisterAllPlastlets() {
  		logger.debug("Unregistering all plastlets");
  		unregisterPlastlets(jdicPlastlets);
  		unregisterPlastlets(acrPlastlets);
  	}
  
  
  
  	private void unregisterPlastlets(Collection<Plastlet> plastlets) {
  		if (plasticManager.isConnected()) {
  			for (Plastlet plastlet : plastlets) {
  				plastlet.unregister();
  			}
  		}
  		plastlets.clear();
 	}
 
 	public void createAndRegisterAllPlastlets() {
 		logger.debug("Creating all Plastlets");
 		if (!plasticManager.isConnected()) {
 			logger.warn("PlastletManager's PlasticManager isn't connected.  Cannot register plastlets.");
 			return; //just to be on the safe side
 		}
 		
 		createAndRegisterJdicPlastlets();
 		createAndRegisterAcrPlastlets();
 	}
 
 
 
 	private synchronized void createAndRegisterJdicPlastlets() {
 		createJdicPlastlets();
 		registerPlastlets(jdicPlastlets);
 	}
 
 
 
 	private synchronized void createAndRegisterAcrPlastlets() {
 		createACRPlastlets();
 		registerPlastlets(acrPlastlets);
 	}
 
 
 
 	private void createJdicPlastlets() {
 		Set<Plastlet> oldJdicPlastlets = new HashSet<Plastlet>(jdicPlastlets);
 		
 		
 		// All the following use the Desktop.
 		if (CheckJDICPresent.desktop.check()) {
 
 			// Browser - could also add a JNLP version of this in case no JDIC.
 			Plastlet browserPlastlet = new BrowserPlastlet(new BrowserPlastlet.BrowserControl() {
 
 				public boolean openURL(URL url) {
 					try {
 						Desktop.browse(url);
 					} catch (DesktopException e) {
 						logger.error("Unable to open url "+url+" in the system browser",e);
 					}
 					return true;
 				}
 
 			}, plasticManager.getId());
 			jdicPlastlets.add(browserPlastlet);
 
 			// Email - currently doesn't work so well due to problems
 			// with jdic
 			Plastlet emailPlastlet = new EmailPlastlet(plasticManager.getId(), new EmailPlastlet.Mailer() {
 
 				public void mail(EmailPlastlet.Message message) throws DesktopException {
 					// Convert between jdics message format, and our own.
 					Message jdicMessage = new Message();
 					jdicMessage.setSubject(message.getSubject());
 					jdicMessage.setBody(message.getBody());
 					try {
 						jdicMessage.setAttachments(message.getAttachments());
 					} catch (IOException e) {
 						logger.warn("One of the attached files was not readable, ignoring", e);
 						jdicMessage.setBody("Unable to attach file");
 					}
 					Desktop.mail(jdicMessage);
 
 				}
 
 			});
 
 			jdicPlastlets.add(emailPlastlet);
 
 			// Print
 			Plastlet printPlastlet = new PrintPlastlet(plasticManager.getId(), new PrintPlastlet.Printer() {
 
 				public void print(File file) throws Exception {
 					Desktop.print(file);
 				}
 			});
 			jdicPlastlets.add(printPlastlet);
 
 			
 		}
 		if (!oldJdicPlastlets.equals(jdicPlastlets)) notifyListeners();
 	}
 
 
 
 	private void registerPlastlets(Collection<Plastlet> plastlets) {
 		final PlasticHubListener hub = plasticManager.getHub();
 		if (hub==null) {
 			logger.debug("Failed to register plastlets - hub not ready");
 			return;
 		}
 		
 		Collection<Plastlet> toRemove = new HashSet<Plastlet>();
 		//register them
 		for (Plastlet plastlet : plastlets) {
 			boolean success;
 			try {
 				
 				success = plastlet.register(hub);
 			} catch (RuntimeException e) {
 				logger.warn("Error when try to register plastlet "+plastlet.getMetaData().getName(),e);
 				success=false;
 			}
 			if (!success) {
 				//must be already registered by someone else
 				toRemove.add(plastlet);
 			}
 		}
 		logger.debug("Created plastlets: "+plastlets.size());
 		logger.debug("Removing: "+toRemove.size());
 		plastlets.removeAll(toRemove);
 		logger.debug("Leaving: "+plastlets.size());
 	}
 
 
 
 	private void createACRPlastlets() {
 		if (!acrManager.isConnected()) return;
 		
 		Set<Plastlet> oldAcrPlastlets = new HashSet<Plastlet>(acrPlastlets);
 		
 		ACR acr = acrManager.getAcr();
 		//Save2MySpace		
 		Plastlet savePlastlet = new SaveToMySpacePlastlet(plasticManager.getId(),acr);
 		acrPlastlets.add(savePlastlet);
 		
 		if (!oldAcrPlastlets.equals(acrPlastlets)) {
 			notifyListeners();
 		}
 	}
 
 	public void hubUp(PlasticHubListener hub) {
 		logger.info("Hub started");
 		createAndRegisterAllPlastlets();
 	}
 
 	public void hubDown() {
 		logger.info("Hub stopped");
 		unregisterAllPlastlets();
 		acrPlastlets.clear();
 		jdicPlastlets.clear();
 		notifyListeners();
 	}
 
 
 
 	public void acrUp() {
 		logger.info("ACR Up");
 		createAndRegisterAcrPlastlets();
 	}
 
 
 
 	public void acrDown() {
 		logger.info("ACR Down");
 		Set<Plastlet> oldAcrPlastlets = new HashSet<Plastlet>(acrPlastlets);
 		unregisterPlastlets(acrPlastlets);
 		acrPlastlets.clear();
 		if (!oldAcrPlastlets.equals(acrPlastlets)) notifyListeners();
 	}
 	public void shutDown() {
 		unregisterAllPlastlets();
 		plasticManager.disconnect();
 	}
 	public PlasticManager getPlasticManager() {
 		return plasticManager;
 	}
 	public AcrManager getAcrManager() {
 		return acrManager;
 	}
 	
 }